home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 242_01 / a51.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-01-11  |  17.1 KB  |  700 lines
  1. /*
  2.     HEADER:        CUG242;
  3.     TITLE:        8051 Cross-Assembler (Portable);
  4.     FILENAME:    A51.C;
  5.     VERSION:    0.4;
  6.     DATE:        11/09/1988;
  7.     SEE-ALSO:    A51.H;
  8.     AUTHORS:    William C. Colley III;
  9. */
  10.  
  11. /*
  12.               8051 Cross-Assembler in Portable C
  13.  
  14.         Copyright (c) 1985,1987 William C. Colley, III
  15.  
  16. Revision History:
  17.  
  18. Ver    Date        Description
  19.  
  20. 0.0    JUL 1987    Adapted from version 0.0 of my portable 8048 cross-
  21.             assembler.  WCC3.
  22.  
  23. 0.1    OCT 1987    Changed the order of DW constants and made trailing
  24.             colons on labels get trashed.  WCC3.
  25.  
  26. 0.2    AUG 1988    Fixed bug that swapped the machine codes for CPL A and
  27.             CLR A.  WCC3.
  28.  
  29. 0.3    AUG 1988    Fixed a bug in the command line parser that puts it
  30.             into a VERY long loop if the user types a command line
  31.             like "A51 FILE.ASM -L".  WCC3 per Alex Cameron.
  32.  
  33. 0.4    NOV 1988    Fixed a bug that made DJNZ direct,relative generate
  34.             the wrong opcode.  WCC3.
  35.  
  36. This file contains the main program and line assembly routines for the
  37. assembler.  The main program parses the command line, feeds the source lines
  38. to the line assembly routine, and sends the results to the listing and object
  39. file output routines.  It also coordinates the activities of everything.  The
  40. line assembly routine uses the expression analyzer and the lexical analyzer to
  41. parse the source line convert it into the object bytes that it represents.
  42. */
  43.  
  44. /*  Get global goodies:  */
  45.  
  46. #include "a51.h"
  47.  
  48. /*  Define global mailboxes for all modules:                */
  49.  
  50. char errcode, line[MAXLINE + 1], title[MAXLINE];
  51. int pass = 0;
  52. int eject, filesp, forwd, listhex;
  53. unsigned address, bytes, errors, listleft, obj[MAXLINE], pagelen, pc;
  54. FILE *filestk[FILES], *source;
  55. TOKEN token;
  56.  
  57. /*  Mainline routine.  This routine parses the command line, sets up    */
  58. /*  the assembler at the beginning of each pass, feeds the source text    */
  59. /*  to the line assembler, feeds the result to the listing and hex file    */
  60. /*  drivers, and cleans everything up at the end of the run.        */
  61.  
  62. static int done, ifsp, off;
  63.  
  64. void main(argc,argv)
  65. int argc;
  66. char **argv;
  67. {
  68.     SCRATCH unsigned *o;
  69.     int newline();
  70.     void asm_line();
  71.     void lclose(), lopen(), lputs();
  72.     void hclose(), hopen(), hputc();
  73.     void error(), fatal_error(), warning();
  74.  
  75.     printf("8051 Cross-Assembler (Portable) Ver 0.4\n");
  76.     printf("Copyright (c) 1985,1987 William C. Colley, III\n\n");
  77.  
  78.     while (--argc > 0) {
  79.     if (**++argv == '-') {
  80.         switch (toupper(*++*argv)) {
  81.         case 'L':   if (!*++*argv) {
  82.                 if (!--argc) { warning(NOLST);  break; }
  83.                 else ++argv;
  84.                 }
  85.                 lopen(*argv);
  86.                 break;
  87.  
  88.         case 'O':   if (!*++*argv) {
  89.                 if (!--argc) { warning(NOHEX);  break; }
  90.                 else ++argv;
  91.                 }
  92.                 hopen(*argv);
  93.                 break;
  94.  
  95.         default:    warning(BADOPT);
  96.         }
  97.     }
  98.     else if (filestk[0]) warning(TWOASM);
  99.     else if (!(filestk[0] = fopen(*argv,"r"))) fatal_error(ASMOPEN);
  100.     }
  101.     if (!filestk[0]) fatal_error(NOASM);
  102.  
  103.     while (++pass < 3) {
  104.     fseek(source = filestk[0],0L,0);  done = off = FALSE;
  105.     errors = filesp = ifsp = pagelen = pc = 0;  title[0] = '\0';
  106.     while (!done) {
  107.         errcode = ' ';
  108.         if (newline()) {
  109.         error('*');
  110.         strcpy(line,"\tEND\n");
  111.         done = eject = TRUE;  listhex = FALSE;
  112.         bytes = 0;
  113.         }
  114.         else asm_line();
  115.         pc = word(pc + bytes);
  116.         if (pass == 2) {
  117.         lputs();
  118.         for (o = obj; bytes--; hputc(*o++));
  119.         }
  120.     }
  121.     }
  122.  
  123.     fclose(filestk[0]);  lclose();  hclose();
  124.  
  125.     if (errors) printf("%d Error(s)\n",errors);
  126.     else printf("No Errors\n");
  127.  
  128.     exit(errors);
  129. }
  130.  
  131. /*  Line assembly routine.  This routine gets expressions and tokens    */
  132. /*  from the source file using the expression evaluator and lexical    */
  133. /*  analyzer, respectively.  It fills a buffer with the machine code    */
  134. /*  bytes and returns nothing.                        */
  135.  
  136. static char label[MAXLINE];
  137. static int ifstack[IFDEPTH] = { ON };
  138.  
  139. static OPCODE *opcod;
  140.  
  141. void asm_line()
  142. {
  143.     SCRATCH char *p;
  144.     SCRATCH int i;
  145.     int isalph(), popc();
  146.     OPCODE *find_code(), *find_operator();
  147.     void do_label(), flush(), normal_op(), pseudo_op();
  148.     void error(), pops(), pushc(), trash();
  149.  
  150.     address = pc;  bytes = 0;  eject = forwd = listhex = FALSE;
  151.     for (i = 0; i < BIGINST; obj[i++] = NOP);
  152.  
  153.     label[0] = '\0';
  154.     if ((i = popc()) != ' ' && i != '\n') {
  155.     if (isalph(i)) {
  156.         pushc(i);  pops(label);
  157.         for (p = label; *p; ++p);
  158.         if (*--p == ':') *p = '\0';
  159.         if (find_operator(label)) { label[0] = '\0';  error('L'); }
  160.     }
  161.     else {
  162.         error('L');
  163.         while ((i = popc()) != ' ' && i != '\n');
  164.     }
  165.     }
  166.  
  167.     trash(); opcod = NULL;
  168.     if ((i = popc()) != '\n') {
  169.     if (!isalph(i)) error('S');
  170.     else {
  171.         pushc(i);  pops(token.sval);
  172.         if (!(opcod = find_code(token.sval))) error('O');
  173.     }
  174.     if (!opcod) { listhex = TRUE;  bytes = BIGINST; }
  175.     }
  176.  
  177.     if (opcod && opcod -> attr & ISIF) { if (label[0]) error('L'); }
  178.     else if (off) { listhex = FALSE;  flush();  return; }
  179.  
  180.     if (!opcod) { do_label();  flush(); }
  181.     else {
  182.     listhex = TRUE;
  183.     if (opcod -> attr & PSEUDO) pseudo_op();
  184.     else normal_op();
  185.     while ((i = popc()) != '\n') if (i != ' ') error('T');
  186.     }
  187.     source = filestk[filesp];
  188.     return;
  189. }
  190.  
  191. static void flush()
  192. {
  193.     while (popc() != '\n');
  194. }
  195.  
  196. static void do_label()
  197. {
  198.     SCRATCH SYMBOL *l;
  199.     SYMBOL *find_symbol(), *new_symbol();
  200.     void error();
  201.  
  202.     if (label[0]) {
  203.     listhex = TRUE;
  204.     if (pass == 1) {
  205.         if (!((l = new_symbol(label)) -> attr)) {
  206.         l -> attr = FORWD + VAL;
  207.         l -> valu = pc;
  208.         }
  209.     }
  210.     else {
  211.         if (l = find_symbol(label)) {
  212.         l -> attr = VAL;
  213.         if (l -> valu != pc) error('M');
  214.         }
  215.         else error('P');
  216.     }
  217.     }
  218. }
  219.  
  220. static void normal_op()
  221. {
  222.     SCRATCH unsigned *o, rmax, rmin, u;
  223.     int grab_a(), grab_comma(), grab_reg();
  224.     unsigned bit_expr(), dir_expr(), expr(), imm_expr();
  225.     TOKEN *lex();
  226.     void do_label(), error(), pushc(), s_error(), unlex();
  227.  
  228.     do_label();  o = obj;  *o = opcod -> valu;
  229.     rmax = (rmin = opcod -> attr & RARG) + ((opcod -> attr & RARGS) >> 5);
  230.     switch (opcod -> attr & OTYPE) {
  231.     case MOV:    if (!grab_reg()) {
  232.                 u = token.valu;
  233.                 if (grab_comma()) { s_error();  return; }
  234.                 switch (u) {
  235.                 case A:        if ((lex() -> attr & TYPE)
  236.                         == IMM) {
  237.                         *o = 0x74;  *++o = imm_expr();
  238.                         break;
  239.                         }
  240.                         *o = 0xe4;  unlex();  goto dec;
  241.                             
  242.                 case C:        *o = 0xa2;  *++o = bit_expr();
  243.                         break;
  244.  
  245.                 case DPTR:  if ((lex() -> attr & TYPE)
  246.                         == IMM) {
  247.                         *o = 0x90;  goto ljmp;
  248.                         }
  249.                         s_error();  return;
  250.  
  251.                 default:    if (u >= AT_R0 && u <= R7) {
  252.                         if (!grab_a()) *o = 0xf4 + u;
  253.                         else if ((token.attr & TYPE)
  254.                             == IMM) {
  255.                             *o = 0x74 + u;
  256.                             *++o = imm_expr();
  257.                         }
  258.                         else {
  259.                             *o = 0xa4 + u;  unlex();
  260.                             *++o = dir_expr();
  261.                         }
  262.                         break;
  263.                         }
  264.                         s_error();  return;
  265.                 }
  266.             }
  267.             else if ((token.attr & TYPE) == BVAL) {
  268.                 unlex();  u = bit_expr();
  269. move_bit:            if ((token.attr & TYPE) != SEP || grab_reg() ||
  270.                 token.valu != C) {
  271.                 s_error();  return;
  272.                 }
  273.                 *o = 0x92;  *++o = low(u);
  274.             }
  275.             else{
  276.                 unlex();  u = dir_expr();
  277.                 if ((token.attr & TYPE) == DOT) {
  278.                 token.attr = VAL;  token.valu = u;  unlex();
  279.                 pushc('.');  u = bit_expr();  goto move_bit;
  280.                 }
  281.                 if ((token.attr & TYPE) != SEP) {
  282.                 s_error();  return;
  283.                 }
  284.                 if (!grab_a()) { *o = 0xf5, *++o = u; }
  285.                 else if ((token.attr & TYPE) == IMM) {
  286.                 *o = 0x75;  *++o = u;  *++o = imm_expr();
  287.                 }
  288.                 else if ((token.attr & TYPE) != REG) {
  289.                 unlex();  *o++ = 0x85;  *++o = u;
  290.                 o[-1] = dir_expr();
  291.                 }
  292.                 else if (token.valu >= AT_R0 &&
  293.                 token.valu <= R7) {
  294.                 *o = 0x84 + token.valu;  *++o = u;
  295.                 }
  296.                 else if (token.valu == C) {
  297.                 *o = 0x92;  *++o = u;
  298.                 }
  299.                 else { s_error();  return; }
  300.             }
  301.             break;
  302.  
  303.     case MOVX:    if (grab_reg()) { s_error();  return; }
  304.             switch (token.valu) {
  305.                 case A:        if (!grab_comma() &&
  306.                         !grab_reg()) {
  307.                         if (token.valu == AT_DPTR)
  308.                             break;
  309.                         unlex();  goto swap;
  310.                         }
  311.                         s_error();  return;
  312.  
  313.                 case AT_R0:
  314.                 case AT_R1:        *o += token.valu;
  315.  
  316.                 case AT_DPTR:   *o += 0x10;
  317.                         if (!grab_comma() && !grab_a())
  318.                         break;
  319.  
  320.                 default:        s_error();  return;
  321.             }
  322.             break;
  323.  
  324.     case ORL:    if (grab_reg() || token.valu != C) {
  325.                 unlex();  goto xrl;
  326.             }
  327.             if (grab_comma()) { s_error();  return; }
  328.             *o += 0x2e;
  329.             if ((lex() -> attr & TYPE) == OPR &&
  330.                  token.valu == '/') *o += 0x2e;
  331.             else unlex();
  332.             *++o = bit_expr();  break;
  333.  
  334. xrl:    case XRL:    if (!grab_a()) goto do_add;
  335.             unlex(); --*o;
  336.             *++o = dir_expr();
  337.             if ((token.attr & TYPE) == SEP) {
  338.                 if (!grab_a()) { --obj[0];  break; }
  339.                 if ((token.attr & TYPE) == IMM) {
  340.                 *++o = imm_expr();  break;
  341.                 }
  342.             }
  343.             s_error();  return;
  344.  
  345.     case ADD:    if (grab_a()) { s_error();  return; }
  346. do_add:            if (grab_comma()) { s_error();  return; }
  347.             switch (lex() -> attr & TYPE) {
  348.                 case IMM:    *++o = imm_expr();  break;
  349.                     
  350.                 case REG:    unlex();  goto swap;
  351.                     
  352.                 default:    ++*o;  unlex();
  353.                     *++o = dir_expr();  break;
  354.             }
  355.             break;
  356.  
  357.     case DJNZ:    if (!grab_reg()) {
  358.                 if ((u = token.valu) >= R0 && u <= R7 &&
  359.                 !grab_comma()) {
  360.                 *o += u;  goto sjmp;
  361.                 }
  362.             }
  363.             else {
  364.                 unlex();  ++*o;  *++o = dir_expr();
  365.                 if ((token.attr & TYPE) == SEP) goto sjmp;
  366.             }
  367.             s_error();  return;
  368.  
  369.     case CJNE:    if (!grab_reg() && (u = token.valu) <= R7 &&
  370.                 !grab_comma()) {
  371.                 if ((lex() -> attr & TYPE) != IMM) {
  372.                 if (u != A) { s_error();  return; }
  373.                 ++*o;  unlex();  *++o = dir_expr();
  374.                 }
  375.                 else { *o += u;  *++o = imm_expr(); }
  376.                 if ((token.attr & TYPE) == SEP) goto sjmp;
  377.             }
  378.             s_error();  return;
  379.  
  380.     case XCH:    if (grab_a() || grab_comma()) { s_error();  return; }
  381.             goto dec;
  382.  
  383.     case INC:    if (!grab_reg() && token.valu == DPTR) {
  384.                 *o = 0xa3;  break;
  385.             }
  386.             unlex();
  387.             
  388. dec:    case DEC:    if (!grab_reg()) { unlex();  goto swap; }
  389.             unlex();  ++*o;
  390.  
  391.     case POP:    *++o = dir_expr();  break;
  392.  
  393.     case JBIT:    *++o = bit_expr();
  394.             if ((token.attr & TYPE) != SEP) {
  395.                 s_error();  return;
  396.             }
  397.  
  398. sjmp:    case SJMP:    if ((u = word(expr() - (pc + (o != obj ? 3 : 2))))
  399.                 > 0x7f && u < 0xff80) {
  400.                 error('B');  u = (o != obj ? 0xfd : 0xfe);
  401.             }
  402.             *++o = low(u);  break;
  403.  
  404.     case AJMP:    if (((u = expr()) ^ (pc + 2)) & 0xf800) {
  405.                 error('B');  u = 0;
  406.             }
  407.             *o += (u >> 3) & 0xe0;  *++o = low(u);  break;
  408.  
  409. ljmp:    case LJMP:    *++o = high(u = expr());  *++o = low(u);  break;
  410.     
  411.     case CPL:    if (!grab_a()) {
  412.                 *o = (*o == 0xb3 ? 0xf4 : 0xe4);  break;
  413.             }
  414.             unlex();
  415.  
  416.     case SETB:    if (!grab_reg()) {
  417.                 if (token.valu != C) { s_error();  return; }
  418.             }
  419.             else { --*o;  unlex();  *++o = bit_expr(); }
  420.             break;
  421.  
  422.     case MOVC:    if (grab_a() || grab_comma()) { s_error();  return; }
  423.  
  424.     case JMP:    if (grab_reg() || token.valu != AT_A ||
  425.                 (lex() -> attr & TYPE) != OPR ||
  426.                 token.valu != '+' || grab_reg() ||
  427.                 token.valu < rmin || token.valu > rmax) {
  428.                 s_error();  return;
  429.             }
  430.             if (token.valu == PC) *o -= 0x10;
  431.             break;
  432.  
  433.     case XCHD:    if (grab_a() || grab_comma()) { s_error();  return; }
  434.  
  435. swap:    case SWAP:    if (grab_reg() || token.valu < rmin ||
  436.                 token.valu > rmax) {
  437.                 s_error();  return;
  438.             }
  439.             *o += token.valu;  break;
  440.  
  441.     case RET:    break;
  442.     }
  443.     bytes = o - obj + 1;  return;
  444. }
  445.  
  446. static unsigned dir_expr()
  447. {
  448.     unsigned u, expr();
  449.     void error();
  450.     
  451.     if ((u = expr()) > 0xff) { error('V');  return 0; }
  452.     return u;
  453. }
  454.  
  455. static unsigned imm_expr()
  456. {
  457.     unsigned u, expr();
  458.     void error();
  459.     
  460.     if ((u = expr()) > 0xff && u < 0xff80) { error('V');  return 0; }
  461.     return low(u);
  462. }
  463.  
  464. static int grab_a()
  465. {
  466.     TOKEN *lex();
  467.  
  468.     return (lex() -> attr & TYPE) != REG || token.valu != A;
  469. }
  470.  
  471. static int grab_comma()
  472. {
  473.     TOKEN *lex();
  474.  
  475.     return (lex() -> attr & TYPE) != SEP;
  476. }
  477.  
  478. static int grab_reg()
  479. {
  480.     TOKEN *lex();
  481.  
  482.     return (lex() -> attr & TYPE) != REG;
  483. }
  484.  
  485. static void s_error()
  486. {
  487.     unsigned *o;
  488.     void error();
  489.  
  490.     bytes = BIGINST;  error('S');
  491.     for (o = obj; o < obj + BIGINST; *o++ = NOP);
  492. }
  493.  
  494. static void pseudo_op()
  495. {
  496.     SCRATCH char *s;
  497.     SCRATCH unsigned *o, u;
  498.     SCRATCH SYMBOL *l;
  499.     int popc();
  500.     unsigned bit_expr(), expr();
  501.     SYMBOL *find_symbol(), *new_symbol();
  502.     TOKEN *lex();
  503.     void do_label(), error(), fatal_error();
  504.     void hseek(), pushc(), trash(), unlex();
  505.  
  506.     o = obj;
  507.     switch (opcod -> valu) {
  508.     case BIT:   if (label[0]) {
  509.             if (pass == 1) {
  510.                 if (!((l = new_symbol(label)) -> attr)) {
  511.                 l -> attr = FORWD + BVAL;
  512.                 address = l -> valu = bit_expr();
  513.                 }
  514.             }
  515.             else {
  516.                 if (l = find_symbol(label)) {
  517.                 l -> attr = BVAL;  address = bit_expr();
  518.                 if (l -> valu != address) error('M');
  519.                 }
  520.                 else error('P');
  521.             }
  522.             }
  523.             else error('L');
  524.             break;
  525.  
  526.     case DB:    do_label();
  527.             do {
  528.             if ((lex() -> attr & TYPE) == SEP) u = 0;
  529.             else {
  530.                 if (token.attr == STR) {
  531.                 trash();  pushc(u = popc());
  532.                 if (u == ',' || u == '\n') {
  533.                     for (s = token.sval; *s; *o++ = *s++)
  534.                     ++bytes;
  535.                     lex();  continue;
  536.                 }
  537.                 }
  538.                 unlex();
  539.                 if ((u = expr()) > 0xff && u < 0xff80) {
  540.                 u = 0;  error('V');
  541.                 }
  542.             }
  543.             *o++ = low(u);  ++bytes;
  544.             } while ((token.attr & TYPE) == SEP);
  545.             break;
  546.  
  547.     case DS:    do_label();  u = word(pc + expr());
  548.             if (forwd) error('P');
  549.             else {
  550.             pc = u;
  551.             if (pass == 2) hseek(pc);
  552.             }
  553.             break;
  554.  
  555.     case DW:    do_label();
  556.             do {
  557.             if ((lex() -> attr & TYPE) == SEP) u = 0;
  558.             else { unlex();  u = expr(); }
  559.             *o++ = high(u);  *o++ = low(u);
  560.             bytes += 2;
  561.             } while ((token.attr & TYPE) == SEP);
  562.             break;
  563.  
  564.     case ELSE:  listhex = FALSE;
  565.             if (ifsp) off = (ifstack[ifsp] = -ifstack[ifsp]) != ON;
  566.             else error('I');
  567.             break;
  568.  
  569.     case END:   do_label();
  570.             if (filesp) { listhex = FALSE;  error('*'); }
  571.             else {
  572.             done = eject = TRUE;
  573.             if (pass == 2 && (lex() -> attr & TYPE) != EOL) {
  574.                 unlex();  hseek(address = expr());
  575.             }
  576.             if (ifsp) error('I');
  577.             }
  578.             break;
  579.  
  580.     case ENDIF: listhex = FALSE;
  581.             if (ifsp) off = ifstack[--ifsp] != ON;
  582.             else error('I');
  583.             break;
  584.  
  585.     case EQU:   if (label[0]) {
  586.             if (pass == 1) {
  587.                 if (!((l = new_symbol(label)) -> attr)) {
  588.                 l -> attr = FORWD + VAL;  address = expr();
  589.                 if (!forwd) l -> valu = address;
  590.                 }
  591.             }
  592.             else {
  593.                 if (l = find_symbol(label)) {
  594.                 l -> attr = VAL;  address = expr();
  595.                 if (forwd) error('P');
  596.                 if (l -> valu != address) error('M');
  597.                 }
  598.                 else error('P');
  599.             }
  600.             }
  601.             else error('L');
  602.             break;
  603.  
  604.     case IF:    if (++ifsp == IFDEPTH) fatal_error(IFOFLOW);
  605.             address = expr();
  606.             if (forwd) { error('P');  address = TRUE; }
  607.             if (off) { listhex = FALSE;  ifstack[ifsp] = NULL; }
  608.             else {
  609.             ifstack[ifsp] = address ? ON : OFF;
  610.             if (!address) off = TRUE;
  611.             }
  612.             break;
  613.  
  614.     case INCL:  listhex = FALSE;  do_label();
  615.             if ((lex() -> attr & TYPE) == STR) {
  616.             if (++filesp == FILES) fatal_error(FLOFLOW);
  617.             if (!(filestk[filesp] = fopen(token.sval,"r"))) {
  618.                 --filesp;  error('V');
  619.             }
  620.             }
  621.             else error('S');
  622.             break;
  623.  
  624.     case ORG:   u = expr();
  625.             if (forwd) error('P');
  626.             else {
  627.             pc = address = u;
  628.             if (pass == 2) hseek(pc);
  629.             }
  630.             do_label();
  631.             break;
  632.  
  633.     case PAGE:  listhex = FALSE;  do_label();
  634.             if ((lex() -> attr & TYPE) != EOL) {
  635.             unlex();  pagelen = expr();
  636.             if (pagelen > 0 && pagelen < 3) {
  637.                 pagelen = 0;  error('V');
  638.             }
  639.             }
  640.             eject = TRUE;
  641.             break;
  642.  
  643.     case REGI:  if (label[0]) {
  644.             if ((lex() -> attr & TYPE) != REG || forwd ||
  645.                 (u = token.valu) < R0 || u > R7) {
  646.                 error('S');  u = R0;
  647.             }
  648.             if (pass == 1) {
  649.                 if (!((l = new_symbol(label)) -> attr)) {
  650.                 l -> attr = FORWD + REG;
  651.                 address = (l -> valu = u) - R0;
  652.                 }
  653.             }
  654.             else {
  655.                 if (l = find_symbol(label)) {
  656.                 l -> attr = REG;  address = u - R0;
  657.                 if (forwd) error('P');
  658.                 if (l -> valu != u) error('M');
  659.                 }
  660.                 else error('P');
  661.             }
  662.             }
  663.             else error('L');
  664.             break;
  665.  
  666.     case SET:   if (label[0]) {
  667.             if (pass == 1) {
  668.                 if (!((l = new_symbol(label)) -> attr)
  669.                 || (l -> attr & SOFT)) {
  670.                 l -> attr = FORWD + SOFT + VAL;
  671.                 address = expr();
  672.                 if (!forwd) l -> valu = address;
  673.                 }
  674.             }
  675.             else {
  676.                 if (l = find_symbol(label)) {
  677.                 address = expr();
  678.                 if (forwd) error('P');
  679.                 else if (l -> attr & SOFT) {
  680.                     l -> attr = SOFT + VAL;
  681.                     l -> valu = address;
  682.                 }
  683.                 else error('M');
  684.                 }
  685.                 else error('P');
  686.             }
  687.             }
  688.             else error('L');
  689.             break;
  690.  
  691.     case TITL:  listhex = FALSE;  do_label();
  692.             if ((lex() -> attr & TYPE) == EOL) title[0] = '\0';
  693.             else if ((token.attr & TYPE) != STR) error('S');
  694.             else strcpy(title,token.sval);
  695.             break;
  696.  
  697.     }
  698.     return;
  699. }
  700.   if